package com.eduagent.xwqeduagent.app.agent;

import com.eduagent.xwqeduagent.constant.FileConstant;
import com.eduagent.xwqeduagent.model.vo.MindMapResultVO;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.regex.Pattern;

@Slf4j
@Component
public class GenerateMindMap {

    /**
     * 生成思维导图
     * @param content 思维导图内容
     * @param userId 用户ID
     * @param sessionId 会话ID
     * @return 思维导图生成结果
     */
    public MindMapResultVO generateMindMap(String content, String userId, String sessionId) {
        log.info("开始生成思维导图，内容：{}，用户ID：{}", content, userId);

        // Coze API配置
        String cozeApiUrl = "https://api.coze.cn/v3/chat";
        String botId = "7506421529711443977"; // 请替换为实际的botId
        String apiKey = "pat_qm2xo8JAVOw7DGJcgmbpMTENCEst9IBcMt2xxRKig1RJLH9QBHDeEq6jgb2rKCxj"; // 请替换为实际的API密钥

        try {
            // 构建请求体
            cn.hutool.json.JSONObject requestBody = new cn.hutool.json.JSONObject();
            requestBody.set("bot_id", botId);
            requestBody.set("user_id", userId);
            requestBody.set("stream", false);
            requestBody.set("auto_save_history", true);

            // 构建消息内容
            cn.hutool.json.JSONArray additionalMessages = new cn.hutool.json.JSONArray();
            cn.hutool.json.JSONObject message = new cn.hutool.json.JSONObject();
            message.set("role", "user");
            message.set("content", "请根据以下内容生成一个思维导图：" + content);
            message.set("content_type", "text");
            additionalMessages.add(message);

            requestBody.set("additional_messages", additionalMessages);

            // 设置请求头
            HashMap<String, String> headers = new HashMap<>();
            headers.put("Authorization", "Bearer " + apiKey);
            headers.put("Content-Type", "application/json");

            // 发送HTTP请求
            String result = cn.hutool.http.HttpUtil.createPost(cozeApiUrl)
                    .headerMap(headers, true)
                    .body(requestBody.toString())
                    .execute()
                    .body();

            log.info("思维导图生成结果：{}", result);

            // 解析响应
            cn.hutool.json.JSONObject responseJson = new cn.hutool.json.JSONObject(result);

            // 检查状态
            if (responseJson.containsKey("data") && responseJson.getJSONObject("data").containsKey("status")) {
                String status = responseJson.getJSONObject("data").getStr("status");
                String conversationId = responseJson.getJSONObject("data").getStr("conversation_id");
                String chatId = responseJson.getJSONObject("data").getStr("id");

                if ("in_progress".equals(status)) {
                    // 如果状态是"in_progress"，需要轮询获取结果
                    return pollForMindMapResult(conversationId, botId, apiKey, chatId);
                } else if ("completed".equals(status)) {
                    // 如果已完成，直接处理结果
                    return processMindMapResult(responseJson, sessionId);
                } else {
                    // 其他状态处理
                    log.warn("思维导图生成状态未知：{}", status);
                    return MindMapResultVO.builder()
                            .status("erroe")
                            .message("思维导图状态未知"+status)
                            .build();
                }
            } else {
                // 保存原始响应
                String mindMapPath = FileConstant.FILE_SAVE_DIR + "/mindmaps/" + sessionId + "_mindmap_raw.json";
                cn.hutool.core.io.FileUtil.writeString(result, mindMapPath, "UTF-8");

                            return MindMapResultVO.builder()
                    .status("error")
                    .message("思维导图生成请求已提交，但响应格式不符合预期，已保存原始响应到：" + mindMapPath)
                    .build();
            }
        } catch (Exception e) {
            log.error("生成思维导图失败", e);

            return MindMapResultVO.builder()
                    .status("erroe")
                    .message("生成思维导图失败：" + e.getMessage())
                    .build();
        }
    }

    /**
     * 轮询获取思维导图生成结果
     */
    private MindMapResultVO pollForMindMapResult(String conversationId, String botId, String apiKey, String sessionId) {
        // 构造API地址
        String checkStatusUrl = "https://api.coze.cn/v3/chat/message/list?" +
                "chat_id=" + sessionId +
                "&conversation_id=" + conversationId;

        // 请求头配置
        HashMap<String, String> headers = new HashMap<>();
        headers.put("Authorization", "Bearer " + apiKey);
        headers.put("Content-Type", "application/json");

        // 最多尝试20次，每次间隔3秒
        for (int i = 0; i < 20; i++) {
            try {
                Thread.sleep(6000);
                String result = cn.hutool.http.HttpUtil.createGet(checkStatusUrl)
                        .headerMap(headers, true)
                        .execute()
                        .body();

                cn.hutool.json.JSONObject responseJson = new cn.hutool.json.JSONObject(result);

                // 检查响应状态码
                if (responseJson.getInt("code") == 0 && responseJson.containsKey("data")) {
                    // 获取消息列表
                    cn.hutool.json.JSONArray messages = responseJson.getJSONArray("data");

                    // 遍历消息找到tool_response类型的消息
                    for (int j = 0; j < messages.size(); j++) {
                        cn.hutool.json.JSONObject message = messages.getJSONObject(j);
                        if ("tool_response".equals(message.getStr("type"))) {
                            // 提取思维导图URL
                            String content = message.getStr("content");
                            if (content != null && content.contains("static.shutu.cn")) {
                                // 保存思维导图内容
                                return processMindMapResult(message, sessionId);
                            }
                        }
                    }

                    // 如果找不到tool_response，继续轮询
                    log.info("思维导图生成中，继续等待...");
                } else {
                    log.warn("思维导图生成失败，响应异常：{}", result);

                                    return MindMapResultVO.builder()
                        .status("error")
                        .message("思维导图生成失败，请检查响应状态")
                        .build();
                }
            } catch (Exception e) {
                log.error("轮询思维导图状态失败", e);
            }
        }

        return MindMapResultVO.builder()
                .status("erroe")
                .message("思维导图生成超时，请稍后查看结果")
                .build();
    }

    /**
     * 处理思维导图生成结果
     * @param sessionId 会话ID（用于文件命名）
     * @return 结果信息（包含文件路径或错误信息）
     */
    private MindMapResultVO processMindMapResult(cn.hutool.json.JSONObject messageJson, String sessionId) {
        try {
            // 1. 从消息中提取content字段
            String content = messageJson.getStr("content");
            if (cn.hutool.core.util.StrUtil.isBlank(content)) {
                throw new IllegalArgumentException("消息中缺少content字段");
            }

            // 2. 解析content中的URL
            String imageUrl = null;
            String editUrl = null;

            // 使用正则表达式提取图片URL和编辑URL
            java.util.regex.Pattern imagePattern = java.util.regex.Pattern.compile("https://static\\.shutu\\.cn/[^\\s]+\\.jpeg");
            java.util.regex.Matcher imageMatcher = imagePattern.matcher(content);
            if (imageMatcher.find()) {
                imageUrl = imageMatcher.group();
            }

            java.util.regex.Pattern editPattern = java.util.regex.Pattern.compile("https://gapi\\.shutu\\.cn/ai/edit-mind-url\\?[^)\s]+", Pattern.CASE_INSENSITIVE);
            java.util.regex.Matcher editMatcher = editPattern.matcher(content);
            if (editMatcher.find()) {
                editUrl = editMatcher.group();
            }

            if (imageUrl == null) {
                throw new IllegalArgumentException("无法从响应中提取思维导图图片URL");
            }

            // 3. 构建存储路径
            String fileName = sessionId + "_mindmap.json";
            String saveDir = FileConstant.FILE_SAVE_DIR + "/mindmaps/";

            // 确保目录存在
            cn.hutool.core.io.FileUtil.mkdir(saveDir);
            String filePath = saveDir + fileName;

            // 4. 创建结构化的思维导图数据
            cn.hutool.json.JSONObject mindMapData = new cn.hutool.json.JSONObject();
            mindMapData.put("image_url", imageUrl);
            mindMapData.put("edit_url", editUrl);
            mindMapData.put("raw_content", content);
            mindMapData.put("created_at", new java.util.Date());

            // 5. 保存文件
            cn.hutool.core.io.FileUtil.writeUtf8String(mindMapData.toString(), filePath);

            // 6. 下载图片（可选）
            String imagePath = saveDir + sessionId + "_mindmap.jpeg";
            try {
                cn.hutool.http.HttpUtil.downloadFile(imageUrl, new java.io.File(imagePath));
            } catch (Exception e) {
                log.warn("下载思维导图图片失败：{}", e.getMessage());
            }

            // 7. 构建返回结果
            return MindMapResultVO.builder()
                    .status("success")
                    .imagePath(imagePath)
                    .imageUrl(imageUrl)
                    .editUrl(editUrl)
                    .filePath(filePath)
                    .build();
        } catch (Exception e) {
            // 8. 异常处理
            String errorMessage = "处理思维导图结果失败";
            if (e instanceof IllegalArgumentException) {
                log.warn("{}：{}", errorMessage, e.getMessage());
                return MindMapResultVO.builder()
                        .status("erroe")
                        .message(errorMessage)
                        .build();
            } else {
                log.error(errorMessage, e);
                return MindMapResultVO.builder()
                        .status("erroe")
                        .message( errorMessage + "：" + e.getClass().getSimpleName())
                        .build();
            }
        }
    }

}
